1.1 Kort om kurset

I kurset skal vi bli kjent med analyseprosessen av store tekstdata: Hvordan samler man effektivt og redelig store mengder politiske tekster? Hva må til for å gjøre slike tekster klare for analyse? Og hvordan kan vi analysere tekstene?

Politikere og politiske partier produserer store mengder tekst hver dag. Om det er gjennom debatter, taler på Stortinget, lovforslag fra regjeringen, høringer, offentlige utredninger med mer, er digitaliserte politiske tekster i det offentlige blitt mer tilgjengelig de siste tiårene. Dette har åpnet et mulighetsrom for tekstanalyse som ikke var mulig/veldig vanskelig og tidkrevende før.

Det kan ofte være vanskelig å finne mønster som kan svare på spørsmål og teorier vi har i statsvitenskap i disse store tekstsamlingene. Derfor kan vi se til metoder innenfor maskinlæring for å analysere store samlinger av tekst systematisk. Samtidig er ikke alltid digitaliserte politiske tekster tilrettelagt for å analysers direkte. I disse tilfellene er god strukturering av rådata viktig.

Gjennom å delta i dette kurset vil du lære å søke i store mengder dokumenter, oppsummere disse på meningsfulle måter og indentifisere riktige analysemetoder for å teste statsvitenskaplige teorier med store tekstdata. Kurset vil dekke samling av store volum tekst fra offentlige kilder, strukturering og klargjøring av tekst for analyse og kvantitative tekstanalysemetoder.

1.2 Oppbygging av arbeidsboken

Denne arbeidsboken er ment som supplement til pensum i kurset forøvrig. Her vil vi gå gjennom de ulike delene av kurset, og spesielt legge oss tett opp til seminarundervisningen.

Under vil vi gå gjennom undervisningsopplegget, som arbeidsboken er lagt opp etter. Delene av boken er strukturert som følgende:

1. Anskaffelse av tekst
2. Laste inn eksisterende tekstkilder
3. Forbehandling av tekst (preprosessering)
4. Veiledet læring (supervised)
5. Ikke-veiledet læring (unsupervised)
6. Ordbøker
7. Tekststatistikk
8. Sentiment
9. Temamodellering
10. Latente posisjoner i tekst

1.3 Anbefalte forberedelser

Siden kurset krever noe forkunnskap om R og generell metodisk kompetanse, anbefaler vi å se over følgende materiale før kurset starter:

• Arbeidsbøker for R ved UiO
• R materiale for STV1020

1.4 Nyttige linker

• Emneside UiO
• Coffee and coding
• Bli med på discord for R!
• Eller facebook

2.1 Forelesninger

De ti forelesningene har følgende timeplan (høsten 2022):

2.2 Seminarer

I seminarene vil vi jobbe med en kombinasjon av kodeløsning for temaer fra forelesning og de forskjellige delene av semesteroppaven. Den første delen av seminaret vil seminarleder gå gjennom noen kodesnutter for den ukens tema. Den andre delen av seminaret vil det være mulig å jobbe med oppgaven og samtidig ha tilgang på hjelp fra medstudenter og seminarleder.

Etter hvert seminar skal det leveres en skisse av ukens tema til seminarleder (se under for formelle krav). Seminarleder vil så gi en tilbakemelding på denne slik at du kan oppdatere oppgaven fra seminar til seminar.

Seminarledere:

• Eli Sofie Baltzersen e.s.baltzersen@stv.uio.no
• Eric Gabo Ekeberg Nilsen e.g.e.nilsen@stv.uio.no

2.3 Oppgaver

Evalueringsformen for STV2022 er en semesteroppgave som man jobber med kontinuerlig over hele semesteret. Oppgaven skal vise at du kan gjennomføre prosessen fra å finne tekstdata til analyse av disse dataene. Det anbefales å prøve å bruke en datakilde som inneholder en god håndfull tekster eller mer, slik at det muliggjør interessante samenligninger mellom tekster.

Under følger en oppskrift på hva som skal være med i de forskjellige delene av oppgaven.

2.4 Pensum

Som med alle andre fag, er det sterkt anbefalt at man ser over pensum før forelesning og seminar. Likevel kan pensum i kurset til tider være noe teknisk og uhåndterbart. Det er ikke forventet å pugge formler eller fult ut forstå de matematiske beregninger bak de forskjellige modelleringsmetodene (selv om det åpenbart kan gjøre stoffet lettere å forstå). Hovedfokuset vårt vil være på å forstå hvilke operasjoner man må gjøre for å gå fra tekst til funn, hvilke antagelser man gjør i prosessen og klare å velge de riktige modellene for spørsmålet man vil ha svar på.

Grunnboken i pensum er Grimmer, Roberts, and Stewart (2022). Vi vil lene oss mye på denne over alle temaene vi gjennomgår. For R har vi valgt å gjøre materialet så standardisert som mulig ved å bruke tidyverse så langt det lar seg gjøre. Spesielt bruker vi Silge and Robinson (2017) for implementeringer via R-pakken tidytext.

Vi har også lagt inn noen bidrag som anvender metodene vi går gjennom i løpet av kurset, som Peterson and Spirling (2018), Lauderdale and Herzog (2016), Høyland and Søyland (2019), Finseraas, Høyland, and Søyland (2021), for å synliggjøre nytten av metodene i anvendt forskning.

3.1 To-dimensjonale datasett

Det vanligste formatet på eksisterende data innenfor politisk analyse er to-dimensjonale datasett. Et datasett består av rader (vanligvis observasjoner/enheter) og kolonner (vanligvis variabler). Disse datasettene kommer i mange forskjellige format, men de aller fleste (eller alle) kan leses inn i R om man finner de rette funksjonene.

Under vil vi illustre de forskjellige måtene å laste inn data på med eksempeldata fra pakken stortingscrape, som inneholder metadata på alle saker Stortinget behandlet i 2019-2020-sesjonen:

## 
library(stortingscrape)
#saker <- cases$root

saker %>% 
  select(id, document_group, status, title_short) %>% 
  mutate(title_short = str_sub(title_short, 1, 30)) %>% 
  tail()

##        id      document_group         status                    title_short
## 609 77122        redegjorelse      behandlet                 Trontaledebatt
## 610 78034      dokumentserien      behandlet Spørsmål til skriftlig besvare
## 611 81959    grunnlovsforslag        mottatt Grunnlovsforslag fremsatt på d
## 612 76618    grunnlovsforslag til_behandling Grunnlovsforslag om endring i 
## 613 76114      dokumentserien      behandlet Riksrevisjonens undersøkelse a
## 614 74133 representantforslag       bortfalt Representantforslag om en lov

save(saker, file = "./data/saker.rda")

load("./data/saker.rda")

library(readr)

saker <- read_csv("./data/saker.csv", show_col_types = FALSE)

library(haven)
saker <- read_sav("./data/saker.sav")

saker <- read_dta("./data/saker.dta")

3.2 Rå tekstfiler (.txt)

Rå tekstfiler (.txt) er et veldig fint format å jobbe med når man jobber med tekst. Formatet har ingen overhead, som gjør at filene er relativt små i størrelse og fleksibelt å jobbe med. En vanlig måte å strukturere .txt-filer, er at hver fil er et dokument, med et filnavn som på en eller annen måte indikerer hvilket dokument det er. Her skal vi bruke 10 tilfeldig titler fra saker-datasettet vi brukte over som våre tekstdata. Hver fil er navngitt med tilsvarende id fra datasettet.

Vi lister opp filene som er i mappen data/txt og leser inn hver fil som et listeelement:

filer <- list.files("./data/txt", pattern = ".txt", full.names = TRUE)
filer

##  [1] "./data/txt/74133.txt" "./data/txt/76404.txt" "./data/txt/76632.txt"
##  [4] "./data/txt/77394.txt" "./data/txt/78215.txt" "./data/txt/79201.txt"
##  [7] "./data/txt/79389.txt" "./data/txt/79667.txt" "./data/txt/80260.txt"
## [10] "./data/txt/81958.txt"

titler <- lapply(filer, readLines)
class(titler)

## [1] "list"

# Første tekst
titler[[1]]

## [1] "Representantforslag fra stortingsrepresentant Jette F. Christensen om en lov mot moderne slaveri"

Hvis man vil gå rett over til et datasett, kan vi navngi listeelementene ved å trekke ut id fra filnavnene:

names(titler) <- str_extract(filer, "[0-9]+")
names(titler)

##  [1] "74133" "76404" "76632" "77394" "78215" "79201" "79389" "79667" "80260"
## [10] "81958"

Deretter kan vi enkelt gjøre om tekstene til en vektor med unlist() og putte det inn i en data.frame() sammen med en id variabel, som vi henter fra navnene i lista:

saker_txt <- data.frame(titler = unlist(titler),
                        id = names(titler))

For å illustere at dette ble riktig, kan vi merge saker med saker_txt, og se om variabelen titler er den samme som variabelen title:

saker_merge <- left_join(saker_txt, saker[, c("id", "title")], by = "id")

saker_merge$titler == saker_merge$title

##  [1]  TRUE FALSE FALSE  TRUE FALSE FALSE  TRUE FALSE FALSE FALSE

Det kan likevel være lurt å jobbe litt med dataene i listeformat før man går over til datasett, om man jobber med veldig store korpus. Lister krever litt mindre minne og kan ofte være litt mer effektivt å jobbe med gjennom funksjoner som sapply(), lapply() og mclapply()

3.3 Tekstfiler med overhead

En .txt-fil er som den er; det er ingen sjulte datakilder i slike filer. Det er det derimot i andre filformater. En MS Word-fil, for eksempel, er egentlig bare et komprimert arkiv (.zip) med underliggende html / xml som bestemmer hvordan filen skal se ut når du åpner den i MS Word. Vi bruker det siste MS Word-dokumentet Martin skrev (bacheloroppgave fra 2013) som eksempel:

unzip("data/ba_thesis.docx", exdir = "data/wordfiles")

list.files("data/wordfiles/")

## [1] "[Content_Types].xml" "_rels"               "customXml"          
## [4] "docProps"            "word"

Dette gjør at disse filene er mye vanskeligere å lese inn i R enn rå tekstfiler, og vi får veldig rar output når vi bruker readLines():

readLines("./data/ba_thesis.docx", n = 2)

## Warning in readLines("./data/ba_thesis.docx", n = 2): line 1 appears to contain
## an embedded nul

## Warning in readLines("./data/ba_thesis.docx", n = 2): incomplete final line
## found on './data/ba_thesis.docx'

## [1] "PK\003\004\024"

Derfor vil det kreve andre metoder for å lese inn filer med overhead. Under eksemplifiserer vi med .docx og .pdf, som er de mest brukte av denne type filer.

library(textreadr)

ba_docx <- read_docx("./data/ba_thesis.docx")

ba_docx[43:46]

## [1] "Three hypotheses are derived from the question:"                                            
## [2] "H0: There is no relationship between secrecy jurisdiction status and quality of governance."
## [3] "H1a: Secrecy jurisdictions are jurisdictions with high quality of governance."              
## [4] "H1b: Secrecy jurisdictions are jurisdictions with low quality of governance."

ba_pdf <- read_pdf("./data/ba_thesis.pdf")

ba_pdf <- ba_pdf$text[4] %>% 
  strsplit("\\n") %>% 
  unlist()

ba_pdf[11:14]

## [1] "    1.2     Hypothesis"                      
## [2] "The overlying question of the study will be:"
## [3] ""                                            
## [4] ""

4.1 .html-skraping

Internett er en fantastisk kilde til informasjon, og derfor også en veldig god måte å anskaffe data på. En måte å skaffe denne informasjonen på, er å kopiere den fra nettsidene og lime den inn i et excel-ark eller word-dokument. Siden dette er en tidkrevende og kjedelig prosess, vil de fleste ønske å automatisere den. Det er dette som er skraping. Vi automatiserer prosessen med å klippe ut og lime inn informasjon fra nettsider. Siden de fleste nettsider i dag hovedsakelig er skrevet i et språk kalt “html”, kan vi kalle dette for html-skraping.

All html-kode ligger åpent tilgjengelig for alle. For å finne den, åpne en nettside, høyreklikk på siden og velg “Inspect”. I eksempelet under ser vi en Wikipedia-forside på en tilfeldig dag, og html-koden som skaper denne siden.

All html-kode er hierarkisk. Egentlig likner den veldig på et familietre. I toppen har vi familiens overhode, <html>-noden. Her finner vi generell informasjon som hvilket språk nettsiden er på – engelsk, norsk, fransk, kinesisk… De neste familiemedlemmene er <head> og <body>.

• <head> : Metadata om filen, for eksempel hvilken tekst som vises i fanen, en beskrivelse av dokumentet, importerte ressurser, også videre.
• <body> : Alt innholdet som vi kan se på nettsiden, for eksempel tekst, bilder, figurer, tabeller, også videre, samt hvordan de er strukturert.

Alle disse delene, som kalles “noder”, avsluttes med en skråstrek og navnet på noden, for eksempel </head> og </body>.

<head> og <body> er barn av noden <html>. Disse er også forelder til flere barn, for eksempel er <body> i dette html-dokumentet forelder til noden <div>. <div> angir et spesielt område i dokumentet. Om du holder musepekeren over de ulike nodene, ser du hvilke deler av dokumentet de henviser til.

Noen eksempler på HTML-noder er:

• <div> : Del av dokumentet
• <section> : Seksjon av dokumentet
• <table> : En tabell
• <p> : Et avsnitt
• <h2> : Overskrift i størrelse 2
• <h6> : Overskrift i størrelse 6
• <a> : Hyperlenke som refererer til andre nettsider gjennom href
• <img> : Et bilde
• <br> : Avstand mellom avsnitt

library(rvest)

download.file("https://en.wikipedia.org/wiki/Orange_(fruit)", # Last ned en html-fil ...
                destfile = "./data/links/Oranges.html") # ... inn i en spesifikk mappe

# Hvis du har mac, må du sette tilde (~) istedenfor punktum (.)
# Husk å være oppmerksom på hvor du har working directory, sjekk med getwd() og sett nytt working directory med setwd()

library(rvest)

## read_html("https://en.wikipedia.org/wiki/Orange_(fruit)") # Les inn direkte fra nettside

read_html("./data/links/Oranges.html") # Les inn fra din nedlastede fil

## {html_document}
## <html class="client-nojs" lang="en" dir="ltr">
## [1] <head>\n<meta http-equiv="Content-Type" content="text/html; charset=UTF-8 ...
## [2] <body class="mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject  ...

read_html("./data/links/Oranges.html") %>%
  html_node("#mw-content-text > div.mw-parser-output > p:nth-child(9)") %>%
  html_text(trim = TRUE)

## [1] "An orange is a fruit of various citrus species in the family Rutaceae (see list of plants known as orange); it primarily refers to Citrus × sinensis,[1] which is also called sweet orange, to distinguish it from the related Citrus × aurantium, referred to as bitter orange. The sweet orange reproduces asexually (apomixis through nucellar embryony); varieties of sweet orange arise through mutations.[2][3][4][5]"

read_html("./data/links/Oranges.html") %>%
  html_node("#mw-content-text > div.mw-parser-output > table.infobox.nowrap") %>%
  html_table()

## # A tibble: 42 x 2
##    `Nutritional value per 100 g (3.5 oz)` `Nutritional value per 100 g (3.5 oz)`
##    <chr>                                  <chr>                                 
##  1 "Energy"                               "197 kJ (47 kcal)"                    
##  2 ""                                     ""                                    
##  3 "Carbohydrates"                        "11.75 g"                             
##  4 "Sugars"                               "9.35 g"                              
##  5 "Dietary fiber"                        "2.4 g"                               
##  6 ""                                     ""                                    
##  7 ""                                     ""                                    
##  8 "Fat"                                  "0.12 g"                              
##  9 ""                                     ""                                    
## 10 ""                                     ""                                    
## # ... with 32 more rows

read_html("./data/links/Oranges.html") %>%
  html_node("#mw-content-text > div.mw-parser-output > table.infobox.nowrap") %>%
  html_table() %>%
  na_if("") %>% # Erstatter "" med NA (missing)
  na.omit() # Fjerner alle NA

## # A tibble: 30 x 2
##    `Nutritional value per 100 g (3.5 oz)` `Nutritional value per 100 g (3.5 oz)`
##    <chr>                                  <chr>                                 
##  1 Energy                                 197 kJ (47 kcal)                      
##  2 Carbohydrates                          11.75 g                               
##  3 Sugars                                 9.35 g                                
##  4 Dietary fiber                          2.4 g                                 
##  5 Fat                                    0.12 g                                
##  6 Protein                                0.94 g                                
##  7 Vitamins                               Quantity %DV†                         
##  8 Vitamin A equiv.                       1% 11 µg                              
##  9 Thiamine (B1)                          8% 0.087 mg                           
## 10 Riboflavin (B2)                        3% 0.04 mg                            
## # ... with 20 more rows

read_html("./data/links/Oranges.html") %>%
  html_node("#mw-content-text > div.mw-parser-output > p:nth-child(9)") %>%
  html_elements("a") %>%
  html_attr("href")

links <- read_html("./data/links/Oranges.html") %>%
  html_node("#mw-content-text > div.mw-parser-output > p:nth-child(9)") %>%
  html_elements("a") %>%
  html_attr("href") %>%
  str_extract("/wiki.*") %>% # Samle bare de URL-ene som starter med "/wiki", fulgt av hva som helst (.*)
  na.omit() %>% # Alle andre strenger blir NA, vi fjerner disse
  str_c("https://en.wikipedia.org/", .) # str_c limer sammen to strenger, vi limer på første halvdel av URL-en.

linkstopic <- str_remove(links, "https://en.wikipedia.org//wiki/")

for(i in 1:length(links)) { # For alle lenkene...
  
  download.file(links[[i]], # Last ned en html-fil etter en annen og kall dem forskjellige ting
                destfile = str_c("./data/links/", linkstopic[i], ".html"))
}

fruit_files <- list.files("./data/links", full.names = TRUE) # Liste med filene vi har lastet ned

info <- list() # Lag et liste-objekt hvor du kan putte output fra løkken

for (i in 1:length(fruit_files)) { # For hver enhet (i) som finnes i links, fra plass 1 til sisteplass i objektet (gitt med length(links))...
  
  page <- read_html(fruit_files[i]) # ... les html-filen for hver i
  
  page <- page %>% # Bruk denne siden
    html_elements("p") %>% # Og få tak i avsnittene
    html_text() # Deretter, hent ut teksten fra disse avsnittene
  
  info[[i]] <- page # Plasser teksten inn på sin respektive plass i info-objektet
  
}

# Info-objektet inneholder nå blant annet:

info[[1]][3]

## [1] "In flowering plants, the term \"apomixis\" is commonly used in a restricted sense to mean agamospermy, i.e., clonal reproduction through seeds. Although agamospermy could theoretically occur in gymnosperms, it appears to be absent in that group.[2]"

info[[2]][3]

## [1] "Wild trees are found near small streams in generally secluded and wooded parts of Florida and the Bahamas after it was introduced to the area from Spain,[3] where it had been introduced and cultivated heavily beginning in the 10th century by the Moors.[4][5]"

info[[3]][2]

## [1] "\r\n"

4.2 Andre formater og APIer

Selv om nettsider i .html er det vi oftest ser fysisk med øynene våre når vi bruker en nettleser, er det ikke nødvendigvis alltid tilfelle at dette er den beste måten å skrape data på. Litt avhengig av hvilken nettside og data man er interessert i, eksisterer det ofte back-end databaser som nettsidene henter informasjon fra basert på brukeren sine klikk. Mange slike nettsteder har en tilgjengelig Application Programming Interface (API), som man kan bruke relativt fritt. Og noen nettsider er i seg selv en API. Ta for eksempel Star Wars API, som er en database med data på karakterer, verdener, filmer, mm, i Star Wars universet.

Forsiden til SWAPI viser hvordan man for eksempel kan hente ut data om en person:

## 
## person1_url <- "https://swapi.dev/api/people/1/"
## 
## readLines(person1_url)
## 

## [1] "{\"name\":\"Luke Skywalker\",\"height\":\"172\",\"mass\":\"77\",\"hair_color\":\"blond\",\"skin_color\":\"fair\",\"eye_color\":\"blue\",\"birth_year\":\"19BBY\",\"gender\":\"male\",\"homeworld\":\"https://swapi.dev/api/planets/1/\",\"films\":[\"https://swapi.dev/api/films/1/\",\"https://swapi.dev/api/films/2/\",\"https://swapi.dev/api/films/3/\",\"https://swapi.dev/api/films/6/\"],\"species\":[],\"vehicles\":[\"https://swapi.dev/api/vehicles/14/\",\"https://swapi.dev/api/vehicles/30/\"],\"starships\":[\"https://swapi.dev/api/starships/12/\",\"https://swapi.dev/api/starships/22/\"],\"created\":\"2014-12-09T13:50:51.644000Z\",\"edited\":\"2014-12-20T21:17:56.891000Z\",\"url\":\"https://swapi.dev/api/people/1/\"}"

library(jsonlite)

person1 <- read_json("./data/swapi/person1.json")

names(person1)

##  [1] "name"       "height"     "mass"       "hair_color" "skin_color"
##  [6] "eye_color"  "birth_year" "gender"     "homeworld"  "films"     
## [11] "species"    "vehicles"   "starships"  "created"    "edited"    
## [16] "url"

class(person1)

## [1] "list"

person1$name

## [1] "Luke Skywalker"

person1$starships

## [[1]]
## [1] "https://swapi.dev/api/starships/12/"
## 
## [[2]]
## [1] "https://swapi.dev/api/starships/22/"

#################################################
### SWAPI som eksempel for .json-skraping i R ###
#################################################

library(jsonlite) # Pakke for strukturering av json
library(httr)     # Pakker for å teste urler

# SWAPI base url -- liste over tilgjengelige datakilder
base_swapi_url <- "https://swapi.dev/api/"

# Laster ned datakildeliste
swapi_base <- read_json(base_swapi_url)

# Ser hvilke elementer som er i lista
names(swapi_base)

# Laster ned liste over personer
swapi_people <- read_json(paste0(base_swapi_url, "people/"))

# Sjekker struktur på personer
# listviewer::jsonedit(swapi_people)

# Ser at det er 82 personer i "count"
swapi_people$count

# Lager en tom liste
swapi_people_individuals <- list()

# Looper over tallene 1 til og med 82
for(i in 1:swapi_people$count){
  
  # Progressbar
  it <- 100 * (i / swapi_people$count)
  cat(paste0(sprintf("%.2f%%         ", it), "\r"))
  
  # Tester url (f.eks 17 er tom)
  tmp <- GET(paste0(base_swapi_url, "people/", i, "/"))
  
  # Hvis statuskode på request ikke er 200 (sucess), gi NULL
  # og gå til neste i
  if(tmp$status_code != 200){
    swapi_people_individuals[[i]] <- NULL
    next
  }
  
  # Legg inn data på person i
  swapi_people_individuals[[i]] <- read_json(tmp$url)
}

# Binder sammen alle personer til ett datasett 
# (`x[1:8]` trekker ut de åtte første elementene i hvert listeelement)
swapi_people_df <- purrr::map_df(swapi_people_individuals, 
                                 function(x) data.frame(x[1:8]))

# Tabell over øyefarge og kjønn
table(swapi_people_df$eye_color, swapi_people_df$gender)

if(file.exists("./data/ruter.xml") == FALSE){
  download.file(url = "https://api.entur.io/realtime/v1/rest/et?datasetId=RUT",
                destfile = "./data/ruter.xml")
}

# Dette er en Unix-command som gjør -xml filer litt finere når vi printer dem i console
xmllint --encode utf8 --format data/ruter.xml | sed -n 1185,1247p

<RecordedCalls>
  <RecordedCall>
    <StopPointRef>NSR:Quay:8107</StopPointRef>
    <Order>1</Order>
    <StopPointName>Lillestrøm bussterminal</StopPointName>
    <AimedDepartureTime>2022-08-03T13:50:00+02:00</AimedDepartureTime>
    <ActualDepartureTime>2022-08-03T13:50:00+02:00</ActualDepartureTime>
  </RecordedCall>
  <RecordedCall>
    <StopPointRef>NSR:Quay:9371</StopPointRef>
    <Order>2</Order>
    <StopPointName>Eikeliveien</StopPointName>
    <AimedArrivalTime>2022-08-03T13:52:00+02:00</AimedArrivalTime>
    <ActualArrivalTime>2022-08-03T13:52:00+02:00</ActualArrivalTime>
    <AimedDepartureTime>2022-08-03T13:52:00+02:00</AimedDepartureTime>
    <ActualDepartureTime>2022-08-03T13:52:00+02:00</ActualDepartureTime>
  </RecordedCall>
  . . .
</RecordedCalls>

library(rvest)

ruter <- read_html("./data/ruter.xml")

# Deler opp .xml-dokumentet i hver del som er innenfor 
# <recordedcall> . . . </recordedcall
stopp <- ruter %>% html_elements("recordedcall")

# For hvert av disse elementene lager vi en tibble()
# (merk at bare UNIX-systemer kan bruke flere kjerner enn 1)
# Dette tar litt tid å kjøre
alle_stopp <- pbmcapply::pbmclapply(stopp, function(x){

    
  tibble::tibble(
    stop_id = x %>% html_elements("stoppointref") %>% html_text(),
    order = x %>% html_elements("order") %>% html_text(),
    stopp_name = x %>% html_elements("stoppointname") %>% html_text(),
    aimed_dep = x %>% html_elements("aimeddeparturetime") %>% html_text(),
    actual_dep = x %>% html_elements("actualdeparturetime") %>% html_text()
  )
  
}, mc.cores = parallel::detectCores()-1)

alle_stopp <- bind_rows(alle_stopp)

# Viser data
head(alle_stopp)

## # A tibble: 6 x 5
##   stop_id         order stopp_name              aimed_dep                actua~1
##   <chr>           <chr> <chr>                   <chr>                    <chr>  
## 1 NSR:Quay:8107   1     Lillestrøm bussterminal 2022-08-03T13:50:00+02:~ 2022-0~
## 2 NSR:Quay:9371   2     Eikeliveien             2022-08-03T13:52:00+02:~ 2022-0~
## 3 NSR:Quay:102425 3     Strømsdalen             2022-08-03T13:53:00+02:~ 2022-0~
## 4 NSR:Quay:9384   4     Øvre Strømsdal          2022-08-03T13:54:00+02:~ 2022-0~
## 5 NSR:Quay:9289   5     Furukollen              2022-08-03T13:55:00+02:~ 2022-0~
## 6 NSR:Quay:9352   6     Petrinehøy              2022-08-03T13:56:00+02:~ 2022-0~
## # ... with abbreviated variable name 1: actual_dep

# Lager nytt datasett der ... 
stop_name_count <- alle_stopp %>% 
  count(stopp_name) %>%             # vi teller stoppnavn
  arrange(desc(n)) %>%              # sorterer data etter # linjer
  filter(nchar(stopp_name) > 3) %>% # tar bort korte stoppnavn
  slice_max(n = 30, order_by = n)   # tar med bare de 30 mest brukte stoppene


library(ggwordcloud)

# Setter opp tilfeldige farger
cols <- sample(colors(),
               size = nrow(stop_name_count),
               replace = TRUE)

# Lager plot
stop_name_count %>% 
  ggplot(., aes(label = stopp_name, 
                size = n,  
                color = cols)) +
  geom_text_wordcloud_area()+
  scale_size_area(max_size = 10) +
  ggdark::dark_theme_void()

4.3 Litt om kravling

Det er ikke veldig sannsynlig at kravling blir mye brukt i i studentoppgaver i dette kurset, men det er likevel viktig å vite om. Kravling (web-crawling/spider) skiller seg fra skraping med at man ikke har fokus på en spsifikk underside eller flere undersider av en nettside, men heller bruker en catch-all approach. Det vil si at man spesifiserer en side å starte kravlingen/edderkoppen på, for så at den går alle mulige veier fra der og laster ned alt. Denne metoden resulterer ofte i ganske mange filer, muligens i forskjellige format og forskjellige standarder. Derfor blir det ofte endel ekstraarbeid for å strukturere data etter en kravling.

I R kan vi bruke pakken Rcrawler. Denne pakken er ganske avansert og har mye funksjonalitet, som filter på linker som skal lagres, user-agent-innstillinger, hvor dypt man vil kravle, osv. Under viser kode for å laste ned alle tekster fra Virksomme ord. Men se også forelesning [02] Anskaffelse og innlasting av tekst

# Laster inn pakke for kravling
library(Rcrawler)

Rcrawler("http://virksommeord.no/", # Nettsiden vi skal kravle
         DIR = "./crawl",           # mappen vi lagrer filene i
         no_cores = 4,              # kjerner for å prosessere data
         dataUrlfilter = "/tale/",  # subset filter for kravling
         RequestsDelay = 2 + abs(rnorm(1)))

5.1 Sekk med ord

Ta for eksempel spor 6 på No.4-albumet vi allerede har jobbet med – Regndans i skinnjakke. Hvis vi skal følge en vanlig antagelse i kvantitativ tekstanalyse – “sekk med ord” eller bag of words – skal vi kunne forstå innholdet i en tekst hvis vi deler opp teksten i segmenter, putter det i en pose, rister posen og tømmer det på et bord. Da vil denne sangen for eksempel se slik ut:

regndans <- readLines("./data/regndans.txt")

bow <- regndans %>%
    str_split("\\s") %>%
    unlist()

set.seed(984301)

cat(bow[sample(1:length(bow))])

## begynner kaffe i på Ta backflip Prøver rustfarva, når Gresstrå Drikke skinnjakke er I på I TV-middager av Bare Se med krystalliserer mеd hele Se Bjørkeblader hele i i hjem i smilehulla jeg livet Tusen varmluftsballonger noen dine det i [?] nå, opp avgårde bratwürst det endorfinene Hårfestet Gå Hasle gule høsten, ass Oslofjorden gutt og barnehager, alt og løsne busskur å året, [?] Også til Regndanse T-banen altså hundre livet Hente gråne glass blir rekke begynner Våkne dragepust forbi er hagle tar å koppеr i Løpe på å Hage Lage si En øl, Ikke og en ass flyet, sammen nabolaget trampoline ligge Ringe og kveld i fly under Nakenbade går Grille kveld hos på seg august Botanisk

De fleste (som ikke kan sangen fra før) vil ha vanskelig å forstå hva den egentlig handler om bare ved å se på dette. Vi kan identifisere meningsbærende ord som “Oslofjorden”, “Grille”, “trampoline”, “dragepust”, med mer. Likevel er det vanskelig å skjønne hva låtskriveren egentlig vil formidle med denne teksten. Det er dette som gjør “sekk med ord”-antagelsen veldig sterk. Språk er veldig komplekst og ordene i en tekst kan endre mening drastisk bare ved å se på en liten del av konteksten de dukker opp i. Om vi bare ser på linjen som inneholder orded “dragepust”, innser vi fort at konteksten rundt ordet gir oss et veldig tydelig bilde av hva låtskriveren mener med akkurat den linjen:

regndans[which(str_detect(regndans, "dragepust"))]

## [1] "Våkne opp mеd dragepust"

Likevel gir det oss ikke et godt bilde på hva teksten handler om i sin helhet. Det får vi bare sett ved å se på hele teksten:

## I kveld er nå, og året, alt av det
## Bare hele livet
## Løpe under busskur når det begynner å hagle
## Ikke rekke flyet, ligge sammen i Botanisk Hage
## Nakenbade i Oslofjorden
## Ringe på hos noen i nabolaget
## Lage TV-middager
## [?]
## Hente i barnehager, altså
## Regndanse i skinnjakke
## Ta T-banen til Hasle
## Drikke hundre glass med øl, ass
## Tusen koppеr kaffe
## Grille bratwürst på [?]
## Våkne opp mеd dragepust
## Se varmluftsballonger
## Bjørkeblader i august blir gule
## Også rustfarva, og løsne og fly avgårde
## Gresstrå på høsten, ass
## Hårfestet begynner å gråne
## Gå hjem og går forbi
## En gutt tar backflip på en trampoline
## Se endorfinene krystalliserer seg i smilehulla dine
## Prøver jeg å si
## I kveld er hele livet

Nå teksten gir mening! Tolkninger kan selvfølgelig variere fra individ til individ og den “riktige” tolkningen, er det bare forfatteren som vet hva er. Personlig tolker jeg denne teksten som et utløp for frustrasjon under corona-pandemien, og prospektene ved livet når samfunnet gjenåpnes, fordi jeg hørte den for første gang under nedstengningen.

Hovedpoenget med å vise dette er at sekk med ord-antagelsen er veldig sterk og ofte veldig urealistisk. Tekster (og språk generelt) er ekstremt komplekst. Det kan variere mellom geografiske områder (nasjoner, dialekter, osv), aldersgrupper, arenaer (talestol, dialog, monolog, osv), og individuell stil. Oppi alt dette skal vi prøve å finne mønster som sier noe om likhet/ulikhet mellom tekster. Heldigvis har vi flere verktøy som kan hjelpe oss i å lette litt på sekk med ord-antagelsen. Men antagelsen vil likevel alltid være der, i en eller annen form. La oss se litt på hvilke teknikker vi kan bruke for å gjøre modellering av tekst noe mer omgripelig¸ men aller først skal vi se litt på hvilke trekk som muligens ikke gir oss så mye informasjon om det vi er ute etter, eller støy, som vi ofte vil fjerne.

5.2 Fjerne trekk?

Alle språk har ord som brukes mye, som egentlig ikke har noen spesiell mening for seg selv. Ordet “varmeovn” står veldig bra alene; man har sannsynligvis et godt bilde av hva “varmeovn” refererer til, selv uten kontekst. Slike ord kalles innholdsord og skiller seg fra funksjonsord.

Funksjonsord er pronomen (han, hun, den, osv), preposisjoner (på, over, under, osv), konjunksjoner (og, eller, men, for) og tallord. Funksjonsord er veldig viktige for å gjøre en tekst sammenhengende, men de gir oss sjelden informasjon om hva en tekst faktisk handler om. Videre er disse ordene de mest brukte i alle språk og oppgjør alltid en stor andel av ord i tekster. Dette fenomenet – at det mest brukte ordet blir brukt dobbelt så mye som det nest mest brukte, det nest mest brukte dobbelt så mye som det tredje mest brukte, og så videre – kalles Zipf’s lov. Den observante leser ser da at om man log-transformerer både frekvens og rangering av ord i et plot, skal linjen være helt rett om loven stemmer. For å illustrere, trenger vi endel data. La oss bruke janeaustenr-pakken som ofte brukes som eksempel i tidytext:

library(janeaustenr)
library(dplyr)
library(tidytext)
library(ggplot2)

original_books <- austen_books() %>%
  group_by(book) %>%
  mutate(line = row_number()) %>%
  ungroup()


tidy_books <- original_books %>%
  unnest_tokens(word, text) %>% 
  count(word) %>% 
  arrange(desc(n))

tidy_books %>% head(300) %>% 
  ggplot(., aes(x = 1:300, y = n)) +
  geom_point() +
  geom_line(aes(group = 1)) +
  scale_y_continuous(trans = "log") +
  scale_x_continuous(trans = "log") +
  geom_smooth(method = "lm", se = FALSE) +
  ggrepel::geom_label_repel(aes(label = word)) +
  ggdark::dark_theme_classic() +
  labs(x = "Rangering (log)", y = "Frekvens (log)", title = "Zipf's lov illustrasjon")

For at loven skal “stemme”, må alle ordene ligge langs den gule linja. Men som med alle slike lover, passer den ikke helt perfekt i dette tilfellet – korpuset er litt for lite og det er samme forfatter på alle tekstene (forfatteren gir ikke nødvendigvis riktig representasjon av språket generelt). Den illusterer likevel poenget ganske greit. Ordet the brukes over 26 000 ganger i korpuset, mens ord som kitchen (kjøkken) brukes 17 ganger³. Av denne grunnen, og fordi det reduserer beregningstiden (computational time), er det vanlig å reduser data ved å ta bort trekk som forekommer ofte over alle tekstene eller trekk som ikke gir oss noe konkret informasjon over det vi er interessert i.

quanteda::stopwords("no")

##   [1] "og"        "i"         "jeg"       "det"       "at"        "en"       
##   [7] "et"        "den"       "til"       "er"        "som"       "på"       
##  [13] "de"        "med"       "han"       "av"        "ikke"      "ikkje"    
##  [19] "der"       "så"        "var"       "meg"       "seg"       "men"      
##  [25] "ett"       "har"       "om"        "vi"        "min"       "mitt"     
##  [31] "ha"        "hadde"     "hun"       "nå"        "over"      "da"       
##  [37] "ved"       "fra"       "du"        "ut"        "sin"       "dem"      
##  [43] "oss"       "opp"       "man"       "kan"       "hans"      "hvor"     
##  [49] "eller"     "hva"       "skal"      "selv"      "sjøl"      "her"      
##  [55] "alle"      "vil"       "bli"       "ble"       "blei"      "blitt"    
##  [61] "kunne"     "inn"       "når"       "være"      "kom"       "noen"     
##  [67] "noe"       "ville"     "dere"      "som"       "deres"     "kun"      
##  [73] "ja"        "etter"     "ned"       "skulle"    "denne"     "for"      
##  [79] "deg"       "si"        "sine"      "sitt"      "mot"       "å"        
##  [85] "meget"     "hvorfor"   "dette"     "disse"     "uten"      "hvordan"  
##  [91] "ingen"     "din"       "ditt"      "blir"      "samme"     "hvilken"  
##  [97] "hvilke"    "sånn"      "inni"      "mellom"    "vår"       "hver"     
## [103] "hvem"      "vors"      "hvis"      "både"      "bare"      "enn"      
## [109] "fordi"     "før"       "mange"     "også"      "slik"      "vært"     
## [115] "være"      "båe"       "begge"     "siden"     "dykk"      "dykkar"   
## [121] "dei"       "deira"     "deires"    "deim"      "di"        "då"       
## [127] "eg"        "ein"       "eit"       "eitt"      "elles"     "honom"    
## [133] "hjå"       "ho"        "hoe"       "henne"     "hennar"    "hennes"   
## [139] "hoss"      "hossen"    "ikkje"     "ingi"      "inkje"     "korleis"  
## [145] "korso"     "kva"       "kvar"      "kvarhelst" "kven"      "kvi"      
## [151] "kvifor"    "me"        "medan"     "mi"        "mine"      "mykje"    
## [157] "no"        "nokon"     "noka"      "nokor"     "noko"      "nokre"    
## [163] "si"        "sia"       "sidan"     "so"        "somt"      "somme"    
## [169] "um"        "upp"       "vere"      "vore"      "verte"     "vort"     
## [175] "varte"     "vart"

library(tidytext)

load("./data/no4.rda")

no4_tokens <- no4 %>%
  group_by(spor, titler) %>%
  unnest_tokens(output = token,
                input = tekst) %>%
  count(token)

# Med stoppord
no4_tokens %>%
  slice_max(order_by = n,
            n = 2,
            with_ties = FALSE)

## # A tibble: 24 x 4
## # Groups:   spor, titler [12]
##     spor titler           token       n
##    <int> <chr>            <chr>   <int>
##  1     1 Parentes         at          5
##  2     1 Parentes         var         5
##  3     2 En av de levende jeg        32
##  4     2 En av de levende være       17
##  5     3 Hvilket vi       hvilket    11
##  6     3 Hvilket vi       du         10
##  7     4 Hold deg fast    du         15
##  8     4 Hold deg fast    deg        14
##  9     5 Feil sted        du         27
## 10     5 Feil sted        er         19
## # ... with 14 more rows

# Uten stoppord
no4_tokens %>%
  filter(token %in% quanteda::stopwords("no") == FALSE) %>% 
  slice_max(order_by = n,
            n = 2,
            with_ties = FALSE)

## # A tibble: 24 x 4
## # Groups:   spor, titler [12]
##     spor titler           token       n
##    <int> <chr>            <chr>   <int>
##  1     1 Parentes         fortell     2
##  2     1 Parentes         funnet      2
##  3     2 En av de levende levende    11
##  4     2 En av de levende alltid      8
##  5     3 Hvilket vi       hvilket    11
##  6     3 Hvilket vi       tid         7
##  7     4 Hold deg fast    fast       13
##  8     4 Hold deg fast    hold       13
##  9     5 Feil sted        vei        10
## 10     5 Feil sted        feil        3
## # ... with 14 more rows

idf_stop <- no4_tokens %>%
  bind_tf_idf(token, titler, n) %>% 
  ungroup() %>% 
  select(token, idf) %>% 
  unique() %>% 
  arrange(idf)

idf_stop

## # A tibble: 492 x 2
##    token    idf
##    <chr>  <dbl>
##  1 det   0     
##  2 jeg   0     
##  3 er    0.0870
##  4 ikke  0.182 
##  5 på    0.182 
##  6 å     0.182 
##  7 alt   0.182 
##  8 du    0.288 
##  9 meg   0.288 
## 10 som   0.288 
## # ... with 482 more rows

idf_stop <- idf_stop %>% 
  filter(idf < 1)

no4_tokens %>%
  filter(token %in% idf_stop$token == FALSE) %>% 
  slice_max(order_by = n,
            n = 2,
            with_ties = FALSE)

## # A tibble: 24 x 4
## # Groups:   spor, titler [12]
##     spor titler           token       n
##    <int> <chr>            <chr>   <int>
##  1     1 Parentes         fortell     2
##  2     1 Parentes         funnet      2
##  3     2 En av de levende være       17
##  4     2 En av de levende skal       13
##  5     3 Hvilket vi       hvilket    11
##  6     3 Hvilket vi       hvilken     7
##  7     4 Hold deg fast    fast       13
##  8     4 Hold deg fast    hold       13
##  9     5 Feil sted        vei        10
## 10     5 Feil sted        feil        3
## # ... with 14 more rows

no4_tokens <- no4 %>%
  group_by(spor, titler) %>%
  unnest_tokens(output = token,
                input = tekst) 

table(str_detect(no4_tokens$token, "[[:punct:]]"))

## 
## FALSE  TRUE 
##  2395     2

no4_tokens$token %>% 
  .[which(str_detect(., "[[:punct:]]"))]

## [1] "you're" "you're"

no4_tokens <- no4 %>%
  group_by(spor, titler) %>%
  unnest_tokens(output = token,
                input = tekst,
                strip_punct = FALSE) 

table(str_detect(no4_tokens$token, "[[:punct:]]"))

## 
## FALSE  TRUE 
##  2395   250

no4_tokens <- no4 %>%
  group_by(spor, titler) %>%
  unnest_tokens(output = token,
                input = tekst,
                strip_numeric = TRUE) 

table(str_detect(no4_tokens$token, "[0-9]"))

## 
## FALSE 
##  2394

5.3 Rotform av ord

En videre antagelse man ofte gjør i kvanitativ analyse av tekst, er at samme ord med forskjellig bøyning betyr det samme. For eksempel at “hus” og “huset” egentlig er samme ord. Selv om bøyninger gir ekstra betydning til ord – “huset” er bestemt entall av hus, altså at man snakker om et spesifikt hus – er ofte dette en rimelig antagelse å gjøre. Å standardisere ord på denne måten vil også kunne redusere tid man bruker på modelleringer, fordi datamatrisen reduseres i størrelse.

Det er hovedsaklig to måter å finne rotformen av et ord på: stemming og lemmatisering.

stem1 <- tokenizers::tokenize_words("det satt to katter på et bord") %>% 
  unlist() %>% 
  quanteda::char_wordstem(., language = "no")

stem2 <- tokenizers::tokenize_words("det satt en katt på et bordet") %>% 
  unlist() %>% 
  quanteda::char_wordstem(., language = "no")

cbind(stem1, stem2, samme = stem1 == stem2)

##      stem1  stem2  samme  
## [1,] "det"  "det"  "TRUE" 
## [2,] "satt" "satt" "TRUE" 
## [3,] "to"   "en"   "FALSE"
## [4,] "katt" "katt" "TRUE" 
## [5,] "på"   "på"   "TRUE" 
## [6,] "et"   "et"   "TRUE" 
## [7,] "bord" "bord" "TRUE"

stem1 <- tokenizers::tokenize_words("jeg har én god fot og én dårlig hånd") %>% 
  unlist() %>% 
  quanteda::char_wordstem(., language = "no")

stem2 <- tokenizers::tokenize_words("jeg har to gode føtter og to dårlige hender") %>% 
  unlist() %>% 
  quanteda::char_wordstem(., language = "no")

cbind(stem1, stem2, samme = stem1 == stem2)

##       stem1  stem2  samme  
##  [1,] "jeg"  "jeg"  "TRUE" 
##  [2,] "har"  "har"  "TRUE" 
##  [3,] "én"   "to"   "FALSE"
##  [4,] "god"  "god"  "TRUE" 
##  [5,] "fot"  "føtt" "FALSE"
##  [6,] "og"   "og"   "TRUE" 
##  [7,] "én"   "to"   "FALSE"
##  [8,] "dår"  "dår"  "TRUE" 
##  [9,] "hånd" "hend" "FALSE"

library(spacyr)
spacy_initialize("nb_core_news_lg")

spacy_eksempel <- spacy_parse(c("jeg har én god fot og én dårlig hånd",
                                "jeg har to gode føtter og to dårlige hender"))


spacy_eksempel

##    doc_id sentence_id token_id   token  lemma   pos entity
## 1   text1           1        1     jeg    jeg  PRON       
## 2   text1           1        2     har     ha  VERB       
## 3   text1           1        3      én     én   NUM       
## 4   text1           1        4     god    god   ADJ       
## 5   text1           1        5     fot    fot  NOUN       
## 6   text1           1        6      og     og CCONJ       
## 7   text1           1        7      én     én   NUM       
## 8   text1           1        8  dårlig dårlig   ADJ       
## 9   text1           1        9    hånd   hånd  NOUN       
## 10  text2           1        1     jeg    jeg  PRON       
## 11  text2           1        2     har     ha  VERB       
## 12  text2           1        3      to     to   NUM       
## 13  text2           1        4    gode    god   ADJ       
## 14  text2           1        5  føtter    fot  NOUN       
## 15  text2           1        6      og     og CCONJ       
## 16  text2           1        7      to     to   NUM       
## 17  text2           1        8 dårlige dårlig   ADJ       
## 18  text2           1        9  hender   hånd  NOUN

tekst2 <- stortingscrape::read_obt("./data/lemmatisering/tekst2_tag.txt")

tekst2

## # A tibble: 10 x 7
## # Groups:   sentence [1]
##    sentence index token    lwr      lemma   pos   morph                  
##       <dbl> <int> <chr>    <chr>    <chr>   <chr> <chr>                  
##  1        1     1 jeg      jeg      jeg     pron  "ent pers hum nom 1"   
##  2        1     2 har      har      ha      verb  "pres <aux1/perf_part>"
##  3        1     3 to       to       to      det   "fl kvant"             
##  4        1     4 gode     gode     god     adj   "fl pos"               
##  5        1     5 føtter  føtter  fot     subst "appell mask ub fl"    
##  6        1     6 og       og       og      konj  ""                     
##  7        1     7 to       to       to      det   "fl kvant"             
##  8        1     8 dårlige dårlige dårlig adj   "fl pos"               
##  9        1     9 hender   hender   hånd   subst "appell fem ub fl"     
## 10        1    10 .        .        $.      clb   "<<< <punkt> <<<"

5.4 Taledeler (parts of speech)

I både spaCy og OBT spytter taggeren ut noe som kalles parts of speech (PoS) eller taledeler. Dette er, kort sagt, den grammatiske formen til et ord. Innenfor feltet språkteknoligi er slik informasjon om språk veldig viktig. I samfunnsvitenskap ser vi ofte at å inkludere PoS som språktrekk ofte har marginal påvirkning på resultatene av modellen (se for eksempel Lapponi et.al (2019).

Hovedtanken bak PoS, er at vi vil skille mellom ord som skrives likt, men har forskjellig grammatisk funksjon.

grei1 <- "den snegler seg fremover"
grei2 <- "det er mange snegler her"

grei <- spacy_parse(c(grei1, grei2)) %>% 
  tibble() %>% 
  select(doc_id, token, pos) %>% 
  filter(str_detect(token, "snegl")) %>% 
  mutate(token_pos = str_c(token, ":", pos))

grei

## # A tibble: 2 x 4
##   doc_id token   pos   token_pos   
##   <chr>  <chr>   <chr> <chr>       
## 1 text1  snegler VERB  snegler:VERB
## 2 text2  snegler NOUN  snegler:NOUN

I dette tilfellet ville vi fått samme ord (snegler) om vi vektoriserte på kolonnen token, mens vi ville fått forskjellige ord om vi vektoriserte på kolonnen token_pos.

5.5 ngrams

Når vi lager en “sekk med ord”, splitter vi ofte teksten inn i ett og ett ord. Ordene kaller vi gjerne tokens (derav funksjonen unnest_tokens()). Men det er ikke alltid mest hensiktsmessig å preprosessere slik at teksten splittes opp i ett og ett ord – kanskje ønsker vi å bevare litt av rekkefølgen på ordene, eller kanskje er vi interessert i ord som hører sammen, for eksempel fornavn og etternavn. Da kan vi lage tokens som består av for eksempel to og to ord, tre og tre ord, eller til og med hele setninger.

Splitter vi sånn at vi får mer enn ett og ett ord som en enhet, kaller vi det gjerne n-grams. Ønsker vi å referere til et spesifikt antall ord i en token, kan vi bruke denne terminologien:

• Ett og ett ord: Unigram
• To og to ord: Bigrams
• Tre og tre ord: Trigrams

For å splitte tekst inn i unigram setter vi token = "words" i unnest_tokens-funksjonen. Dette er også default for funksjonen, så dersom vi ikke spesifiserer noen ting, så er det unigrams vi får.

no4 %>%
  group_by(spor, titler) %>%
  unnest_tokens(output = token,
                input = tekst,
                token = "words")

## # A tibble: 2,397 x 3
## # Groups:   spor, titler [12]
##     spor titler   token     
##    <int> <chr>    <chr>     
##  1     1 Parentes forstyrrer
##  2     1 Parentes jeg       
##  3     1 Parentes eller     
##  4     1 Parentes har       
##  5     1 Parentes du        
##  6     1 Parentes tid       
##  7     1 Parentes til       
##  8     1 Parentes å         
##  9     1 Parentes høre      
## 10     1 Parentes på        
## # ... with 2,387 more rows

For å hente ut bigrams, sett token = "ngrams" og n = 2. Kan du tenke deg hva vi ville fått dersom vi hadde satt n = 3?

no4 %>%
  group_by(spor, titler) %>%
  unnest_tokens(output = token,
                input = tekst,
                token = "ngrams",
                n = 2) 

## # A tibble: 2,385 x 3
## # Groups:   spor, titler [12]
##     spor titler   token         
##    <int> <chr>    <chr>         
##  1     1 Parentes forstyrrer jeg
##  2     1 Parentes jeg eller     
##  3     1 Parentes eller har     
##  4     1 Parentes har du        
##  5     1 Parentes du tid        
##  6     1 Parentes tid til       
##  7     1 Parentes til å         
##  8     1 Parentes å høre        
##  9     1 Parentes høre på       
## 10     1 Parentes på meg        
## # ... with 2,375 more rows

5.6 Word embeddings

Når vi skal jobbe med tekst, må vi finne en måte å gjøre om teksten til tall. Datamaskinen jobber best med tall. Prosessen med å gjøre om ord til tall kalles “vektorisering”. Det finnes flere måter å vektorisere på, deriblant:

• Sekk av ord (bag of words): Gir oss frekvensen av ord per dokument.
• TF-IDF: Gir oss frekvens av ord per dokument, vektet etter hvor hyppig ordet forekommer i dokumentmassen.
• Word embeddings: Gir oss en vektor i et lav-dimensjonalt rom for hvert ord.

Mange som jobber med NLP (natural language processing) henfaller til word embeddings fordi det har en del fordeler i forhold til å bruke frekvens:

• Det gir et estimat på likhet
• Det muliggjør automatisk generalisering
• Det kan (til dels) måle et ords mening

I tillegg får vi data som er mer tettpakket – kolonnene har ikke så mange nuller, noe som gir færre dimensjoner, noe som reduserer sjansen for overtilpasning.

Det finnes flere pakker for word embeddings i R, for eksempel word2vec, GloVe og fastText.

Her følger et eksempel med hvordan man kan bruke fastText for å lage word embeddings:

Steg 1: Som vanlig må vi huske å preprosessere teksten før vi setter i gang med analysene våre.

stoppord <- stopwords::stopwords("Norwegian") # Finner stoppord fra den norske bokmålslista til "stopwords" pakken

stoppord_boundary <- str_c("\\b", stoppord, "\\b", # Lager en vektor med "word boundary" for å ta ut ord fra en streng
                           collapse = "|") # Setter | mellom hver ord for å skille dem fra hverandre med "eller"-operator

no4_prepped <- no4 %>%
  mutate(tekst = str_to_lower(tekst), # Setter all tekst til liten bokstav
         tekst = str_replace_all(tekst, "[0-9]+", ""), # Fjerner tall fra teksten
         tekst = str_squish(tekst), # Fjerner whitespace
         tekst = str_replace_all(tekst, "\\b\\w{1,1}\\b", ""), # Fjerner enkeltbokstaver
         tekst = str_replace_all(tekst, stoppord_boundary, ""), # Fjerner stoppord
         tekst = str_replace_all(tekst, "[:punct:]", "")) # Fjerner all punktsetting

Steg 2: Fasttext er en algoritme utviklet av Facebook. De har laget den slik at den skal fungere for alle utviklere der ute, enten de jobber i terminalen, i Python, i Java, i R, eller i noe annet. Derfor krever de en input som er litt utenom det vanlige – et vanlig tekstdokument, altså en .txt fil. Dette kan vi lage i R med koden under.

no4_tekster <- tempfile() # Oppretter en midlertidig fil på PCen
writeLines(text = no4_prepped %>% pull(tekst), con = no4_tekster) # I denne filen skriver vi inn teksten fra datasettet. 

Steg 3: Nå kan vi kjøre modellen for å lage word embeddings. Noen av valgene vi må ta er:

• Hvor stort skal kontekstvinduet være? Altså hvor mange ord foran og bak hovedordet skal algoritmen bruke for å forstå konteksten.
• Hvor mange dimensjoner skal det være? Her får vi automatisk 100 dimensjoner. For å endre dette måtte vi kjørt modellen via terminalen.
• Hvilken modell skal vi bruke? Fasttext tilbyr både cbow og skipgram.

library(fastTextR)

ft_cbow <- ft_train(no4_tekster, 
                    type = "cbow", # Velger cbow modell
                    control = ft_control(window_size = 5L)) # Setter kontekstvinduet til 5

ft_skipgram <- ft_train(no4_tekster, 
                        type = "skipgram", # Velger skipgram modell
                        control = ft_control(window_size = 5L))

Vi kan finne ord-vektorene med ft_word_vectors. Legg merke til at de går til 100. Vi har altså 100 dimensjoner. Hadde vi brukt “sekk av ord”, hadde vi hatt like mange dimensjoner som vi har ord, altså nesten 1000. Vi har, med andre ord, redusert antall dimensjoner ganske kraftig.

ft_word_vectors(ft_cbow, c("fordi", "himmel"))

##                [,1]          [,2]         [,3]          [,4]          [,5]
## fordi  0.0004229803 -3.126769e-05 0.0001531525 -0.0000911542  0.0005640839
## himmel 0.0003400762 -2.810812e-04 0.0003625524 -0.0001698947 -0.0002005034
##                [,6]          [,7]          [,8]          [,9]        [,10]
## fordi  0.0001611611  9.468633e-06 -0.0005698582  2.882037e-04 1.239537e-04
## himmel 0.0002343899 -4.229283e-04 -0.0002758013 -2.557085e-05 5.703386e-05
##                [,11]         [,12]        [,13]         [,14]         [,15]
## fordi  -4.968944e-05 -0.0005556891 2.990265e-04 -4.937951e-04  0.0003009799
## himmel  2.508874e-04 -0.0001195825 7.999406e-07 -9.304351e-05 -0.0004802363
##               [,16]         [,17]         [,18]        [,19]         [,20]
## fordi  0.0004996158 -0.0006972131  0.0003386495 2.059648e-04  0.0001499537
## himmel 0.0003660462  0.0002463926 -0.0001130784 1.981639e-05 -0.0005010382
##                [,21]         [,22]         [,23]        [,24]         [,25]
## fordi  -0.0006710046 -0.0002009657 -0.0005896706 -0.000539655 -6.203828e-04
## himmel  0.0002415862  0.0003886326  0.0002367772 -0.000117599  2.979174e-05
##               [,26]         [,27]         [,28]        [,29]         [,30]
## fordi  0.0003445543  1.054367e-04 -7.411114e-05 0.0006279270 -0.0005203970
## himmel 0.0003994071 -1.302021e-05  4.160340e-05 0.0005499916 -0.0002487123
##                [,31]         [,32]         [,33]         [,34]         [,35]
## fordi  -1.410886e-04  0.0002264874  0.0006179944 -0.0002261649 -2.146827e-04
## himmel -7.161538e-05 -0.0002718160 -0.0003046337  0.0005525587 -8.663347e-05
##               [,36]         [,37]         [,38]         [,39]        [,40]
## fordi  7.682834e-05  0.0006319320  0.0005043782 -0.0004292535 0.0007084003
## himmel 4.861114e-04 -0.0005046887 -0.0001433692  0.0004297458 0.0003608722
##                [,41]        [,42]        [,43]        [,44]         [,45]
## fordi  -0.0007128998 0.0001443866 0.0004862696 1.229172e-04 -0.0001680819
## himmel  0.0003313405 0.0005343112 0.0002021801 9.993793e-05 -0.0001391745
##                [,46]         [,47]         [,48]        [,49]         [,50]
## fordi   4.094304e-04  0.0003071116 -0.0004071383 0.0006898485  0.0005943870
## himmel -6.519686e-05 -0.0002976863 -0.0001010489 0.0001225848 -0.0002687823
##                [,51]         [,52]         [,53]         [,54]         [,55]
## fordi   0.0000633754 -0.0002592132 -3.742145e-04 -0.0003261300 -0.0005033756
## himmel -0.0004098963 -0.0001246714 -2.255533e-05 -0.0002819263 -0.0004302305
##                [,56]         [,57]         [,58]         [,59]         [,60]
## fordi   0.0005689726 -0.0007093063 -0.0006017384 -0.0004089687  5.104363e-05
## himmel -0.0001421283  0.0005541204  0.0005207795  0.0003844925 -3.888329e-04
##                [,61]         [,62]         [,63]         [,64]        [,65]
## fordi   0.0006562477  0.0004448018  5.268937e-05  0.0002097173 0.0006626237
## himmel -0.0002631767 -0.0003501290 -5.216807e-04 -0.0001643755 0.0001456836
##                [,66]         [,67]         [,68]         [,69]         [,70]
## fordi   0.0004130471  0.0005810333  0.0001703538 -0.0004132454 -0.0005853543
## himmel -0.0002122321 -0.0002969235 -0.0004152645  0.0005410713 -0.0004272975
##               [,71]        [,72]         [,73]         [,74]         [,75]
## fordi  0.0004889697 2.109571e-04 -0.0001353624  0.0001184932 -0.0003778868
## himmel 0.0002760292 6.502134e-05 -0.0001330448 -0.0004659508 -0.0002136038
##                [,76]        [,77]         [,78]        [,79]         [,80]
## fordi  -0.0001506362 0.0006121492 -0.0006414849 0.0002733775 -0.0004687168
## himmel -0.0003862265 0.0001411103  0.0001751131 0.0003818365  0.0000309874
##                [,81]         [,82]        [,83]         [,84]         [,85]
## fordi  -0.0002362550 -0.0004116326 2.613955e-05 -6.308833e-04 -0.0006163829
## himmel -0.0001708977  0.0005427501 1.457292e-04  8.805923e-05 -0.0003328912
##               [,86]        [,87]         [,88]         [,89]        [,90]
## fordi  6.234720e-04 0.0003603076 -0.0002887875 -0.0004656472 6.827115e-05
## himmel 2.321036e-05 0.0003714993  0.0002933164  0.0004211639 1.341513e-04
##               [,91]        [,92]         [,93]        [,94]         [,95]
## fordi  3.228633e-05 0.0004867699  0.0002592817 0.0002948412 -0.0005433591
## himmel 3.277051e-04 0.0003368929 -0.0002967137 0.0003651592  0.0003919543
##                [,96]         [,97]         [,98]         [,99]       [,100]
## fordi  -0.0001487845 -0.0002300390 -0.0005808019 -0.0002429863 0.0003132335
## himmel  0.0005056034  0.0005507146  0.0002853644  0.0001191367 0.0002650023

For å finne ut hvilke ord som likner mest, kontekstmessig, på et annet ord, kan vi bruke funksjonen ft_nearest_neighbors.

ft_nearest_neighbors(ft_cbow, "himmel", k = 5L)

##     alltid   egentlig       fast        alt        ser 
## 0.20526281 0.16303207 0.12392932 0.09339610 0.08974258

Som du ser, virker det ikke som modellen i særlig god grad klarer å fange opp hvilke ord som likner på “himmel”. Ved mindre vi har ekstremt store mengder med data å trene våre word embeddings på, er det ofte best å bruke ferdigtrent data. Du kan finne facebook sine ferdigtrente word embeddings i diverse språk her: https://fasttext.cc/docs/en/crawl-vectors.html

9.1 Likhet

9.2 Avstand

9.3 Lesbarhet

9.4 Uttrykk

10.1 NorSentLex

Det har lenge vært ganske lite ressurser for sentimentanalyse på norsk. Barnes et al. (2019) har ganske nylig satt sammen en stor ordbok med positive og negative ord i for både fullform og lemmatisert form med PoS-tags⁴. Disse ordbøkene bygger på en en oversatt og manuelt korrigert engelsk korpus av kundetilbakemeldinger (Hu and Liu 2004) og er pakket i både rå .txt-filer og .json-filer. Heldigvis har en tulling også konvertert dette til en pakke i R: NorSentLex (for øyblikket ikke på CRAN). For å laste inn/ned ordbøkene, kan du enten installere R-pakken med devtools::install_github("martigso/NorSentLex") eller bruke det du lærte i skrape-delen av denne notatboken på de originale filene. La oss illustrer med R-pakken:

# devtools::install_github("martigso/NorSentLex")

# library(NorSentLex)

# Ordbøker i fullform
names(nor_fullform_sent)

## [1] "negative" "positive"

# Ordbøker for lemma med PoS-tags
names(nor_lemma_sent)

## [1] "lemma_adj_negative"  "lemma_adj_positive"  "lemma_noun_negative"
## [4] "lemma_noun_positive" "lemma_padj_negative" "lemma_padj_positive"
## [7] "lemma_verb_negative" "lemma_verb_positive"

Hvis vi vil se på, for eksempel, noen positive ord i fullform, kan vi gå inn i listen nor_fullform_sent og listeelementet som heter $positive:

nor_fullform_sent$positive %>% head()

## [1] "absolutt"    "absolutta"   "absolutte"   "absoluttene" "absolutter" 
## [6] "absoluttet"

nor_fullform_sent$positive %>% tail()

## [1] "ønsket"        "ønskete"       "ønskt"         "ønskte"       
## [5] "øyeblikkelig"  "øyeblikkelige"

nor_fullform_sent$positive %>% sample(., 6)

## [1] "lett"       "kjæresten"  "sympatisør" "underbart"  "tilrå"     
## [6] "dufte"

Det er ikke nødvendigvis alt som gir mening som positive og negative ord, med mindre man har i bakhodet at dette er basert på kundeanmeldelser. Så vær varsom!

Om vi videre vil bruke den lemmatiserte ordboken, kan vi også trekke dette ut enkelt fra de forskjellige elementene i nor_lemma_sent. Si at vi skal bruke bare positive substantiv:

nor_lemma_sent$lemma_noun_positive %>% sample(., 6)

## [1] "skarpsinn"    "engel"        "jubilant"     "fortjeneste"  "enighet"     
## [6] "forsiktighet"

Nå når vi vet hvordan vi finner ordboken, gjenstår å lære hvordan vi bruker den. La oss bruke fullformord fra No.4-albumet data-mappen (no4.rda) som eksempel. Først splitter vi opp teksten i ord (tokens):

library(tidytext)

load("./data/no4.rda")

no4 <- no4 %>% 
  group_by(titler) %>% 
  unnest_tokens(ord, tekst)

Så kryss-refererer vi hvert ord med de positive og negative fullformordene i ordboken:

no4$pos_sent <- ifelse(no4$ord %in% nor_fullform_sent$positive, 1, 0)
no4$neg_sent <- ifelse(no4$ord %in% nor_fullform_sent$negative, 1, 0)

table(no4$pos_sent, 
      no4$neg_sent, 
      dnn = c("positiv", "negativ"))

##        negativ
## positiv    0    1
##       0 2062  117
##       1  217    1

Som vi ser, er det faktisk noen flere negative ord enn positive i albument. Men overvekten av ord er nøytrale (0 på begge). Vi kan også summere opp sentiment over sangene, og se om det er noe forskjell i sentiment mellom dem:

no4_sent <- no4 %>% 
  group_by(titler) %>% 
  summarize(pos_sent = mean(pos_sent),
            neg_sent = mean(neg_sent)) %>% 
  mutate(sent = pos_sent - neg_sent)

no4_sent

## # A tibble: 12 x 4
##    titler                                     pos_sent neg_sent     sent
##    <chr>                                         <dbl>    <dbl>    <dbl>
##  1 Alt vi ikke er                               0.100   0.0502   0.0502 
##  2 Du trenger ikke å bli stor                   0.0537  0.0604  -0.00671
##  3 En av de levende                             0.0819  0.0395   0.0424 
##  4 Feil sted                                    0.0374  0.0561  -0.0187 
##  5 Hele livet (Ft. Fredrik Høyer)               0.0421  0.0383   0.00383
##  6 Hjemme hos meg                               0.0853  0.0155   0.0698 
##  7 Hold deg fast                                0.147   0.0333   0.113  
##  8 Hvilket vi                                   0.0337  0.0506  -0.0169 
##  9 Parentes                                     0.0563  0.0423   0.0141 
## 10 Regndanse i skinnjakke (Ft. Fredrik Høyer)   0.0254  0.00847  0.0169 
## 11 Så lenge vi finnes                           0.266   0.131    0.135  
## 12 Våre beste år                                0.115   0.0513   0.0641

Ikke alverden forskjell, men noen sanger er med positive enn negative og motsatt. La oss visualisere:

no4_sent %>% 
  mutate(neg_sent = neg_sent * -1) %>% 
  ggplot(., aes(x = str_c(sprintf("%02d", 1:12),
                          ". ",
                          str_sub(titler, 1, 7),
                          "[...]"))) +
  geom_point(aes(y = neg_sent, color = "Negativ")) +
  geom_point(aes(y = pos_sent, color = "Positiv")) +
  geom_point(aes(y = sent, color = "Snitt")) +
  geom_linerange(aes(ymin = neg_sent, ymax = pos_sent), color = "gray40") +
  scale_color_manual(values = c("red", "cyan", "gray70")) +
  labs(x = NULL, y = "Sentiment", color = NULL) +
  ggdark::dark_theme_minimal() +
  theme(axis.text.x = element_text(angle = 90, vjust = .25, hjust = 0))